Titre

---------------------------------------- Chapitre I - Les bases ----------------------------------------

L'assembleur

L'assembleur (ou ASM) est le langage informatique le plus proche de la machine. C'est en asm que les compilateurs convertissent les programmes écrits en Visual basic, C/C++, Delphi, DotNet, etc. On parle de langage de bas niveau pour l'ASM et de haut niveau pour les autres.

Basée sur un codage en valeur hexadécimale (base 16), chaque instruction de l'asm peut être représentée soit par sa valeur (on parle alors de l'opcode) ou sous forme de mot clé, beaucoup plus compréhensible pour nous. Par exemple pour un saut : EBh = JMP (le h indique une valeur en hexadécimal, un d indiquera une valeur en décimal).

Nous n'allons pas voir toutes les instructions (il y en a pas mal !), mais les principales qui nous servirons dans les premiers cas que nous allons étudier. Vous découvrirez les autres au fur et à mesure de votre évolution.

MOV (Move)
Syntaxe : MOV Destination, Source

Déplace les données entre registres et mémoires. Le contenu de la source est copié dans la destination sans être changé.

PUSH (Push Word onto Stack)
Syntaxe : PUSH Source

Place sur le haut de la pile les données récupérées dans la source de 16 ou 32 bits (mémoire ou registre).

POP (Pop Word off Stack)
Syntaxe : POP Destination

Permet de restaurer des données stockées sur le dessus de la pile (il s'agit d'un dépilage). La destination est une zone mémoire ou un registre de 16 ou 32 bits.

ADD (arithmetic ADDition)
Syntaxe : ADD Destination, Source

Effectue une addition sans retenue. Le contenu de la source est ajouté à la destination, le résultat étant dans la destination.

SUB (SUBtract)
Syntaxe : SUB Destination, Source

Retranche la source de la destination et stocke le résultat dans la destination. Contrairement à SBB, cette instruction ne prend pas en compte l'indicateur de retenue [CF]. Cette instruction permet d'effectuer une soustraction ordinaire. La source et la destination doivent être de même taille : 8, 16 ou 32 bits.

MUL (unsigned MULtiply)
Syntaxe : MUL Source

Multiplie le contenu de EAX ou AX ou AL (selon la taille du registre donné en paramètre) par la source, les deux nombres étant considérés non signés. Le résultat est transféré dans la destination qui est le registre EAX ou le couple de registres EDX:EAX. Pour les nombres signés, ce sera l'instruction IMUL.

DIV (DIVide)
Syntaxe : DIV Opérande

Cette instruction permet d'effectuer une division non-signée par l'opérande. Selon la taille de l'opérande, on divise AX, ou DX:AX, ou EDX:EAX. Le reste de la division est alors stocké dans AH, ou dans DX, ou dans EDX. Pour les nombres signés, ce sera l'instruction IDIV.

INC (INCrement)
Syntaxe : INC Destination

Incrémente (augmente de 1) la destination, qui peut être un registre ou une mémoire = variable) de 8, 16 ou 32 bits.

DEC (DECrement)
Syntaxe : DEC Destination

Décrémente de 1 (retranche 1) la destination, qui peut être un registre ou une mémoire (= variable) de 8, 16 ou 32 bits.

CMP (CoMPare)
Syntaxe : CMP Destination, Source

La destination est comparée à la source, provoquant une mise à jour des indicateurs. Cela consiste en une soustraction de la source à la destination, sans retenir le résultat, ne faisant que modifier les indicateurs (flags).

CALL (Procedure CALL)
Syntaxe : CALL Destination

Sert à appeler des sous-routines, destination étant l'adresse de début de cette sous-routine.

RET (RETurn From procedure)
Syntaxe : RET / RETF

Met fin au sous-programme et retourne à la ligne de code suivant le CALL.

JMP (JuMP)
Syntaxe : JMP Destination

Permet d'effectuer un saut vers la destination spécifiée.

JA (Jump if Above) : saut si supérieur
JAE  (Jump if Above or Equal) : Saut si supérieur ou égal
JB  (Jump if Below) : saut si inférieur
JBE (Jump if Below or Equal) : saut si inférieur ou égal
JE (Jump if Equal) : saut si égal
JG (Jump if Greater) : saut si supérieur
JGE (Jump if Greater or Equal) : saut si supérieur ou égal
JL (Jump if Less) : saut si inférieur
JLE (Jump if Less or Equal) : saut si inférieur ou égal
JZ (Jump if Zero) : saut si égal (zéro)
JNA (Jump if not Above) : saut si pas supérieur
JNAE (Jump if not Above not Equal) : saut si ni supérieur ni égal
JNB (Jump if not Below) : saut si pas inférieur
JNE (Jump if not Equal) : saut si pas égal (zéro)
JNG (Jump if not Greater) : saut si pas supérieur
JNGE (Jump if not Greater not Equal) : saut si ni supérieur ni égal
JNL (Jump if not Less) : saut si pas inférieur
JNLE (Jump if not Less not Equal) : saut si ni inférieur ni égal
JNZ (Jump if not Zero) : saut si pas égal

Pour d'autres instructions ASM, je vous invite à consulter le fichier d'aide Ollydbg.hlp fourni dans le dossier "pack" de ce tutoriel ou à vous rendre sur des sites comme Gladir.com.

 

Precedent        Sommaire        Suivant